using UnityEngine;
using UI.BankingPanel.Components;
using UI.Common;
using System.IO;

namespace UI.BankingPanel
{
    /// <summary>
    /// 坐庄收款系统视图类
    /// 基础结构，后续填充具体功能
    /// </summary>
    public class BankingView : MonoBehaviour
    {
        #region UI组件引用
        [Header("主面板")]
        [SerializeField] private GameObject mainPanel;
        
        [Header("头部统计组件")]
        [SerializeField] private C_Header_Statistics headerStatistics;
        
        [Header("押注数据滚动列表")]
        [SerializeField] private C_Bet_ScrollView betScrollView;
        
        [Header("风险数据滚动列表")]
        [SerializeField] private C_RiskData_ScrollView riskDataScrollView;
        
        [Header("关闭按钮")]
        [SerializeField] private UnityEngine.UI.Button closeButton;
        
        [Header("清空按钮")]
        [SerializeField] private UnityEngine.UI.Button clearButton;
        
        [Header("导出按钮")]
        [SerializeField] private UnityEngine.UI.Button exportButton;
        #endregion
        
        #region 私有变量
        // 清空确认相关变量
        private bool isWaitingForClearConfirmation = false;
        private bool clearConfirmationReceived = false;
        
        // 按钮文本组件（支持TextMeshPro和传统Text）
        private UnityEngine.UI.Text clearButtonText;
        private TMPro.TextMeshProUGUI clearButtonTextTMP;
        
        // 按钮文本状态
        private readonly string defaultClearButtonText = "清空数据";
        private readonly string confirmClearButtonText = "确认清空";
        private readonly string clearingButtonText = "清空中...";
        #endregion

        #region 初始化
        /// <summary>
        /// 初始化视图
        /// </summary>
        public void Initialize()
        {
            FindUIComponents();
            InitializeComponents();
            Debug.Log("BankingView initialized");
        }

        /// <summary>
        /// 查找UI组件
        /// </summary>
        private void FindUIComponents()
        {
            if (mainPanel == null)
            {
                mainPanel = transform.Find("M_Panel")?.gameObject;
            }
            
            // 查找头部统计组件
            if (headerStatistics == null)
            {
                // 方法1: 直接查找C_Header_Statistics节点
                var headerStatsTransform = transform.Find("C_Header_Statistics");
                if (headerStatsTransform == null)
                {
                    // 方法2: 从M_Panel下查找
                    if (mainPanel != null)
                    {
                        headerStatsTransform = mainPanel.transform.Find("C_Header_Statistics");
                    }
                }
                
                if (headerStatsTransform != null)
                {
                    headerStatistics = headerStatsTransform.GetComponent<C_Header_Statistics>();
                    if (headerStatistics == null)
                    {
                        headerStatistics = headerStatsTransform.gameObject.AddComponent<C_Header_Statistics>();
                    }
                    Debug.Log($"[BankingView] 找到C_Header_Statistics组件: {headerStatsTransform.name}");
                }
                else
                {
                    Debug.LogWarning("[BankingView] 未找到C_Header_Statistics节点，请检查UI结构");
                }
            }
            
            // 查找押注数据滚动列表组件
            if (betScrollView == null)
            {
                // 方法1: 直接查找C_Bet_ScrollView节点
                var betScrollTransform = transform.Find("C_Bet_ScrollView");
                if (betScrollTransform == null)
                {
                    // 方法2: 从M_Panel下查找
                    if (mainPanel != null)
                    {
                        betScrollTransform = mainPanel.transform.Find("C_Bet_ScrollView");
                    }
                }
                
                if (betScrollTransform != null)
                {
                    betScrollView = betScrollTransform.GetComponent<C_Bet_ScrollView>();
                    if (betScrollView == null)
                    {
                        betScrollView = betScrollTransform.gameObject.AddComponent<C_Bet_ScrollView>();
                    }
                }
                else
                {
                    Debug.LogWarning("未找到C_Bet_ScrollView节点，请检查UI结构");
                }
            }
            
            // 查找风险数据滚动列表组件
            if (riskDataScrollView == null)
            {
                // 方法1: 直接查找C_RiskData_ScrollView节点
                var riskScrollTransform = transform.Find("C_RiskData_ScrollView");
                if (riskScrollTransform == null)
                {
                    // 方法2: 从M_Panel下查找
                    if (mainPanel != null)
                    {
                        riskScrollTransform = mainPanel.transform.Find("C_RiskData_ScrollView");
                    }
                }
                
                if (riskScrollTransform != null)
                {
                    riskDataScrollView = riskScrollTransform.GetComponent<C_RiskData_ScrollView>();
                    if (riskDataScrollView == null)
                    {
                        riskDataScrollView = riskScrollTransform.gameObject.AddComponent<C_RiskData_ScrollView>();
                    }
                    Debug.Log($"[BankingView] 找到C_RiskData_ScrollView组件: {riskScrollTransform.name}");
                }
                else
                {
                    Debug.LogWarning("[BankingView] 未找到C_RiskData_ScrollView节点，风险数据功能将不可用");
                }
            }
            
            // 查找关闭按钮
            if (closeButton == null)
            {
                // 方法1: 直接查找C_Close_Button节点
                var closeButtonTransform = transform.Find("C_Close_Button");
                if (closeButtonTransform == null)
                {
                    // 方法2: 从M_Panel下查找
                    if (mainPanel != null)
                    {
                        closeButtonTransform = mainPanel.transform.Find("C_Close_Button");
                    }
                }
                
                if (closeButtonTransform != null)
                {
                    closeButton = closeButtonTransform.GetComponent<UnityEngine.UI.Button>();
                    if (closeButton == null)
                    {
                        Debug.LogWarning("[BankingView] C_Close_Button节点存在但没有Button组件");
                    }
                    else
                    {
                        Debug.Log($"[BankingView] 找到关闭按钮: {closeButtonTransform.name}");
                    }
                }
                else
                {
                    Debug.LogWarning("[BankingView] 未找到C_Close_Button节点，请检查UI结构");
                }
            }
            
            // 查找清空按钮
            if (clearButton == null)
            {
                // 方法1: 直接查找C_Clear_Button节点
                var clearButtonTransform = transform.Find("C_Clear_Button");
                if (clearButtonTransform == null)
                {
                    // 方法2: 从M_Panel下查找
                    if (mainPanel != null)
                    {
                        clearButtonTransform = mainPanel.transform.Find("C_Clear_Button");
                    }
                }
                
                if (clearButtonTransform != null)
                {
                    clearButton = clearButtonTransform.GetComponent<UnityEngine.UI.Button>();
                    if (clearButton == null)
                    {
                        Debug.LogWarning("[BankingView] C_Clear_Button节点存在但没有Button组件");
                    }
                    else
                    {
                        Debug.Log($"[BankingView] 找到清空按钮: {clearButtonTransform.name}");
                        
                        // 查找按钮文本组件
                        FindClearButtonText(clearButtonTransform);
                    }
                }
                else
                {
                    Debug.LogWarning("[BankingView] 未找到C_Clear_Button节点，请检查UI结构");
                }
            }
            
            // 查找导出按钮
            if (exportButton == null)
            {
                // 方法1: 直接查找C_Export_Button节点
                var exportButtonTransform = transform.Find("C_Export_Button");
                if (exportButtonTransform == null)
                {
                    // 方法2: 从M_Panel下查找
                    if (mainPanel != null)
                    {
                        exportButtonTransform = mainPanel.transform.Find("C_Export_Button");
                    }
                }
                
                if (exportButtonTransform != null)
                {
                    exportButton = exportButtonTransform.GetComponent<UnityEngine.UI.Button>();
                    if (exportButton == null)
                    {
                        Debug.LogWarning("[BankingView] C_Export_Button节点存在但没有Button组件");
                    }
                    else
                    {
                        Debug.Log($"[BankingView] 找到导出按钮: {exportButtonTransform.name}");
                    }
                }
                else
                {
                    Debug.LogWarning("[BankingView] 未找到C_Export_Button节点，请检查UI结构");
                }
            }
        }
        
        /// <summary>
        /// 查找清空按钮的文本组件（支持TextMeshPro和传统Text）
        /// </summary>
        /// <param name="buttonTransform">按钮Transform</param>
        private void FindClearButtonText(Transform buttonTransform)
        {
            if (clearButtonText == null && clearButtonTextTMP == null)
            {
                // 优先查找TextMeshPro组件
                // 方法1: 直接从按钮节点获取TextMeshPro组件
                clearButtonTextTMP = buttonTransform.GetComponent<TMPro.TextMeshProUGUI>();
                
                if (clearButtonTextTMP == null)
                {
                    // 方法2: 从子节点查找TextMeshPro组件
                    clearButtonTextTMP = buttonTransform.GetComponentInChildren<TMPro.TextMeshProUGUI>();
                }
                
                if (clearButtonTextTMP == null)
                {
                    // 方法3: 查找常见的文本节点名称（TextMeshPro）
                    var textTransforms = new string[] { "Text", "Label", "txt", "text", "Text (TMP)", "TextMeshPro" };
                    foreach (var textName in textTransforms)
                    {
                        var textTransform = buttonTransform.Find(textName);
                        if (textTransform != null)
                        {
                            clearButtonTextTMP = textTransform.GetComponent<TMPro.TextMeshProUGUI>();
                            if (clearButtonTextTMP != null)
                            {
                                break;
                            }
                        }
                    }
                }
                
                // 如果没找到TextMeshPro，再查找传统Text组件
                if (clearButtonTextTMP == null)
                {
                    // 方法1: 直接从按钮节点获取Text组件
                    clearButtonText = buttonTransform.GetComponent<UnityEngine.UI.Text>();
                    
                    if (clearButtonText == null)
                    {
                        // 方法2: 从子节点查找Text组件
                        clearButtonText = buttonTransform.GetComponentInChildren<UnityEngine.UI.Text>();
                    }
                    
                    if (clearButtonText == null)
                    {
                        // 方法3: 查找常见的文本节点名称（传统Text）
                        var textTransforms = new string[] { "Text", "Label", "txt", "text" };
                        foreach (var textName in textTransforms)
                        {
                            var textTransform = buttonTransform.Find(textName);
                            if (textTransform != null)
                            {
                                clearButtonText = textTransform.GetComponent<UnityEngine.UI.Text>();
                                if (clearButtonText != null)
                                {
                                    break;
                                }
                            }
                        }
                    }
                }
                
                // 检查是否找到了文本组件
                if (clearButtonTextTMP != null)
                {
                    Debug.Log($"[BankingView] 找到清空按钮TextMeshPro文本组件: {clearButtonTextTMP.name}");
                    // 设置初始文本
                    SetClearButtonText(defaultClearButtonText);
                }
                else if (clearButtonText != null)
                {
                    Debug.Log($"[BankingView] 找到清空按钮传统Text文本组件: {clearButtonText.name}");
                    // 设置初始文本
                    SetClearButtonText(defaultClearButtonText);
                }
                else
                {
                    Debug.LogWarning("[BankingView] 未找到清空按钮的文本组件（TextMeshPro或Text），文本状态同步功能将不可用");
                }
            }
        }
        
        /// <summary>
        /// 设置清空按钮文本（支持TextMeshPro和传统Text）
        /// </summary>
        /// <param name="text">要设置的文本</param>
        private void SetClearButtonText(string text)
        {
            if (clearButtonTextTMP != null)
            {
                clearButtonTextTMP.text = text;
                Debug.Log($"[BankingView] 清空按钮TextMeshPro文本已更新为: {text}");
            }
            else if (clearButtonText != null)
            {
                clearButtonText.text = text;
                Debug.Log($"[BankingView] 清空按钮传统Text文本已更新为: {text}");
            }
            else
            {
                Debug.LogWarning($"[BankingView] 无法设置清空按钮文本为'{text}'，未找到文本组件");
            }
        }
        
        /// <summary>
        /// 初始化组件
        /// </summary>
        private void InitializeComponents()
        {
            // 初始化头部统计组件
            if (headerStatistics != null)
            {
                headerStatistics.Initialize();
            }
            
            // 初始化押注数据滚动列表组件
            if (betScrollView != null)
            {
                betScrollView.Initialize(OnBetDataFieldChanged);
            }
            
            // 初始化风险数据滚动列表组件
            if (riskDataScrollView != null)
            {
                // 风险数据组件的初始化将在BankingCtrl中进行，这里只是确保组件存在
                Debug.Log("[BankingView] 风险数据滚动列表组件已准备就绪");
            }
            
            // 初始化关闭按钮
            if (closeButton != null)
            {
                closeButton.onClick.AddListener(OnCloseButtonClicked);
                Debug.Log("[BankingView] 关闭按钮事件绑定完成");
            }
            
            // 初始化清空按钮
            if (clearButton != null)
            {
                clearButton.onClick.AddListener(OnClearButtonClicked);
                Debug.Log("[BankingView] 清空按钮事件绑定完成");
            }
            
            // 初始化导出按钮
            if (exportButton != null)
            {
                exportButton.onClick.AddListener(OnExportButtonClicked);
                Debug.Log("[BankingView] 导出按钮事件绑定完成");
            }
        }
        
        /// <summary>
        /// 押注数据字段变化回调
        /// </summary>
        /// <param name="numberId">号码ID</param>
        /// <param name="fieldType">字段类型</param>
        /// <param name="newValue">新值</param>
        private void OnBetDataFieldChanged(int numberId, Components.BetDataFieldType fieldType, float newValue)
        {
            // 这里可以处理押注数据字段变化的逻辑
            Debug.Log($"[BankingView] 号码{numberId}的{fieldType}字段已更新为: {newValue}");
            
            // 可以在这里通知控制器或其他组件
            // 例如：通知BankingCtrl更新数据模型
        }
        
        /// <summary>
        /// 关闭按钮点击事件处理
        /// </summary>
        private void OnCloseButtonClicked()
        {
            Debug.Log("[BankingView] 关闭按钮被点击，准备关闭程序");
            
            // 显示关闭确认提示
            if (ToastSystem.Instance != null)
            {
                ToastSystem.ShowToast("程序即将关闭...", 2.0f);
            }
            
            // 延迟关闭，给用户看到提示的时间
            StartCoroutine(CloseApplicationDelayed(1.0f));
        }
        
        /// <summary>
        /// 清空按钮点击事件处理
        /// </summary>
        private void OnClearButtonClicked()
        {
            Debug.Log("[BankingView] 清空按钮被点击");
            
            if (isWaitingForClearConfirmation)
            {
                // 如果正在等待确认，这是第二次点击，直接执行清空
                Debug.Log("[BankingView] 确认清空，开始执行");
                
                // 重置确认状态
                isWaitingForClearConfirmation = false;
                clearConfirmationReceived = false;
                
                // 直接执行清空操作
                ExecuteClearAllData();
            }
            else
            {
                // 第一次点击，显示确认状态
                Debug.Log("[BankingView] 显示确认清空状态");
                
                // 设置等待确认状态
                isWaitingForClearConfirmation = true;
                
                // 更新按钮文本为确认状态
                SetClearButtonText(confirmClearButtonText);
                
                // 显示确认提示
                if (ToastSystem.Instance != null)
                {
                    ToastSystem.ShowToast("再次点击确认清空所有数据", 2.0f);
                }
                
                // 启动5秒超时重置
                StartCoroutine(ResetConfirmationAfterTimeout(5.0f));
            }
        }
        
        /// <summary>
        /// 延迟关闭应用程序
        /// </summary>
        /// <param name="delay">延迟时间（秒）</param>
        private System.Collections.IEnumerator CloseApplicationDelayed(float delay)
        {
            yield return new UnityEngine.WaitForSeconds(delay);
            
            Debug.Log("[BankingView] 正在关闭应用程序...");
            
            #if UNITY_EDITOR
                // 在编辑器中停止播放
                UnityEditor.EditorApplication.isPlaying = false;
            #else
                // 在构建版本中退出应用程序
                Application.Quit();
            #endif
        }
        
        /// <summary>
        /// 超时后重置确认状态
        /// </summary>
        /// <param name="timeoutSeconds">超时时间（秒）</param>
        private System.Collections.IEnumerator ResetConfirmationAfterTimeout(float timeoutSeconds)
        {
            yield return new UnityEngine.WaitForSeconds(timeoutSeconds);
            
            // 如果仍在等待确认状态，则重置
            if (isWaitingForClearConfirmation)
            {
                isWaitingForClearConfirmation = false;
                clearConfirmationReceived = false;
                
                // 恢复按钮文本
                SetClearButtonText(defaultClearButtonText);
                
                if (ToastSystem.Instance != null)
                {
                    ToastSystem.ShowToast("清空操作已取消", 2.0f);
                }
                
                Debug.Log("[BankingView] 清空确认已超时，状态已重置");
            }
        }
        
        /// <summary>
        /// 执行清空所有数据
        /// </summary>
        private void ExecuteClearAllData()
        {
            Debug.Log("[BankingView] 开始执行清空所有数据操作");
            
            // 显示清空中状态
            SetClearButtonText(clearingButtonText);
            
            try
            {
                // 通过BankingCtrl清空数据
                var bankingCtrl = GetComponent<BankingCtrl>();
                if (bankingCtrl == null)
                {
                    // 如果当前对象没有BankingCtrl，尝试从父对象查找
                    bankingCtrl = GetComponentInParent<BankingCtrl>();
                }
                
                if (bankingCtrl != null)
                {
                    // 调用BankingCtrl的重置方法
                    bankingCtrl.ResetAllData();
                    
                    // 恢复按钮文本
                    SetClearButtonText(defaultClearButtonText);
                    
                    // 显示成功提示
                    if (ToastSystem.Instance != null)
                    {
                        ToastSystem.ShowToast("所有数据已清空！", 2.0f);
                    }
                    
                    Debug.Log("[BankingView] 数据清空完成");
                }
                else
                {
                    // 恢复按钮文本
                    SetClearButtonText(defaultClearButtonText);
                    
                    Debug.LogError("[BankingView] 未找到BankingCtrl组件，无法清空数据");
                    
                    if (ToastSystem.Instance != null)
                    {
                        ToastSystem.ShowToast("清空失败：未找到控制器", 2.0f);
                    }
                }
            }
            catch (System.Exception ex)
            {
                // 恢复按钮文本
                SetClearButtonText(defaultClearButtonText);
                
                Debug.LogError($"[BankingView] 清空数据时发生错误: {ex.Message}\n{ex.StackTrace}");
                
                if (ToastSystem.Instance != null)
                {
                    ToastSystem.ShowToast("清空失败：发生错误", 2.0f);
                }
            }
        }
        
        /// <summary>
        /// 导出按钮点击事件处理
        /// </summary>
        private void OnExportButtonClicked()
        {
            Debug.Log("[BankingView] 导出按钮被点击");
            
            try
            {
                // 获取BankingCtrl组件
                var bankingCtrl = GetComponent<BankingCtrl>();
                if (bankingCtrl == null)
                {
                    bankingCtrl = GetComponentInParent<BankingCtrl>();
                }
                
                if (bankingCtrl != null)
                {
                    // 获取银行数据
                    var bankingData = bankingCtrl.GetBankingData();
                    
                    if (bankingData != null)
                    {
                        // 显示导出中提示
                        if (ToastSystem.Instance != null)
                        {
                            ToastSystem.ShowToast("正在导出数据...", 1.0f);
                        }
                        
                        // 执行导出（使用真正的Excel格式，同时复制到粘贴板）
                        var result = SimpleExcelExporter.ExportBankingDataToExcel(bankingData, null, true);
                        
                        if (result.Success)
                        {
                            // 导出成功
                            Debug.Log($"[BankingView] 数据导出成功: {result.FilePath}");
                            
                            if (ToastSystem.Instance != null)
                            {
                                ToastSystem.ShowToast($"导出成功！\n文件已保存到:\n{GetDisplayPath(result.FilePath)}\n数据摘要已复制到粘贴板", 5.0f);
                            }
                            
                            // 在安卓平台上，尝试打开文件管理器到导出目录
                            #if UNITY_ANDROID && !UNITY_EDITOR
                                OpenFileManagerOnAndroid(result.FilePath);
                            #endif
                        }
                        else
                        {
                            // 导出失败
                            Debug.LogError($"[BankingView] 数据导出失败: {result.Message}");
                            
                            if (ToastSystem.Instance != null)
                            {
                                ToastSystem.ShowToast($"导出失败: {result.Message}", 3.0f);
                            }
                        }
                    }
                    else
                    {
                        Debug.LogError("[BankingView] 银行数据为空，无法导出");
                        
                        if (ToastSystem.Instance != null)
                        {
                            ToastSystem.ShowToast("数据为空，无法导出", 2.0f);
                        }
                    }
                }
                else
                {
                    Debug.LogError("[BankingView] 未找到BankingCtrl组件，无法导出数据");
                    
                    if (ToastSystem.Instance != null)
                    {
                        ToastSystem.ShowToast("导出失败：未找到控制器", 2.0f);
                    }
                }
            }
            catch (System.Exception ex)
            {
                Debug.LogError($"[BankingView] 导出数据时发生错误: {ex.Message}\n{ex.StackTrace}");
                
                if (ToastSystem.Instance != null)
                {
                    ToastSystem.ShowToast("导出失败：发生错误", 2.0f);
                }
            }
        }
        
        /// <summary>
        /// 获取用于显示的文件路径（简化路径显示）
        /// </summary>
        /// <param name="fullPath">完整路径</param>
        /// <returns>显示用路径</returns>
        private string GetDisplayPath(string fullPath)
        {
            if (string.IsNullOrEmpty(fullPath))
                return "";
                
            #if UNITY_ANDROID && !UNITY_EDITOR
                // 安卓平台显示相对路径
                if (fullPath.Contains("Exports"))
                {
                    int index = fullPath.LastIndexOf("Exports");
                    return "内部存储/Android/data/[应用包名]/files/" + fullPath.Substring(index);
                }
            #endif
            
            return fullPath;
        }
        
        /// <summary>
        /// 在安卓平台打开文件管理器
        /// </summary>
        /// <param name="filePath">文件路径</param>
        private void OpenFileManagerOnAndroid(string filePath)
        {
            #if UNITY_ANDROID && !UNITY_EDITOR
                try
                {
                    // 获取文件目录
                    string directory = Path.GetDirectoryName(filePath);
                    
                    // 使用Android Intent打开文件管理器
                    using (AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
                    using (AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity"))
                    using (AndroidJavaObject intent = new AndroidJavaObject("android.content.Intent"))
                    {
                        intent.Call<AndroidJavaObject>("setAction", "android.intent.action.VIEW");
                        intent.Call<AndroidJavaObject>("setType", "resource/folder");
                        
                        if (intent.Call<AndroidJavaObject>("resolveActivity", currentActivity.Call<AndroidJavaObject>("getPackageManager")) != null)
                        {
                            currentActivity.Call("startActivity", intent);
                            Debug.Log("[BankingView] 已打开文件管理器");
                        }
                        else
                        {
                            Debug.LogWarning("[BankingView] 无法打开文件管理器");
                        }
                    }
                }
                catch (System.Exception ex)
                {
                    Debug.LogWarning($"[BankingView] 打开文件管理器失败: {ex.Message}");
                }
            #endif
        }
        #endregion
        
        #region 公共方法
        /// <summary>
        /// 获取头部统计组件
        /// </summary>
        public C_Header_Statistics GetHeaderStatistics()
        {
            return headerStatistics;
        }
        
        /// <summary>
        /// 获取押注数据滚动列表组件
        /// </summary>
        public C_Bet_ScrollView GetBetScrollView()
        {
            return betScrollView;
        }

        /// <summary>
        /// 获取风险数据滚动列表组件
        /// </summary>
        public C_RiskData_ScrollView GetRiskDataScrollView()
        {
            return riskDataScrollView;
        }
        
        /// <summary>
        /// 设置押注数据列表
        /// </summary>
        /// <param name="betDataList">押注数据列表</param>
        public void SetBetDataList(System.Collections.Generic.List<Data.NumberBetData> betDataList)
        {
            if (betScrollView != null)
            {
                betScrollView.SetBetDataList(betDataList);
            }
        }
        
        /// <summary>
        /// 更新单个号码的押注数据
        /// </summary>
        /// <param name="numberIndex">号码索引</param>
        /// <param name="betData">押注数据</param>
        public void UpdateBetData(int numberIndex, Data.NumberBetData betData)
        {
            if (betScrollView != null)
            {
                betScrollView.UpdateBetData(numberIndex, betData);
            }
        }
        
        /// <summary>
        /// 滚动到指定号码
        /// </summary>
        /// <param name="numberIndex">号码索引（0-48）</param>
        /// <param name="duration">滚动动画时间</param>
        public void ScrollToNumber(int numberIndex, float duration = 0.3f)
        {
            if (betScrollView != null)
            {
                betScrollView.ScrollToNumber(numberIndex, duration);
            }
        }
        
        /// <summary>
        /// 清空所有押注数据（仅清空UI显示）
        /// </summary>
        public void ClearAllBetData()
        {
            if (betScrollView != null)
            {
                betScrollView.ClearAllBetData();
            }
        }
        
        /// <summary>
        /// 清空所有数据（包括数据模型和UI显示）
        /// 外部调用接口，会直接执行清空而不需要确认
        /// </summary>
        public void ClearAllDataDirect()
        {
            ExecuteClearAllData();
        }
        
        /// <summary>
        /// 触发清空按钮点击（模拟用户点击）
        /// </summary>
        public void TriggerClearButton()
        {
            OnClearButtonClicked();
        }
        
        /// <summary>
        /// 重置清空按钮状态
        /// </summary>
        public void ResetClearButtonState()
        {
            isWaitingForClearConfirmation = false;
            clearConfirmationReceived = false;
            SetClearButtonText(defaultClearButtonText);
            Debug.Log("[BankingView] 清空按钮状态已重置");
        }
        
        /// <summary>
        /// 获取清空按钮当前状态
        /// </summary>
        /// <returns>按钮状态描述</returns>
        public string GetClearButtonState()
        {
            if (isWaitingForClearConfirmation)
            {
                return "等待确认";
            }
            else
            {
                return "正常";
            }
        }
        
        /// <summary>
        /// 设置清空按钮的自定义文本（外部调用）
        /// </summary>
        /// <param name="text">要设置的文本</param>
        public void SetClearButtonTextExternal(string text)
        {
            SetClearButtonText(text);
        }
        
        /// <summary>
        /// 获取清空按钮当前文本（支持TextMeshPro和传统Text）
        /// </summary>
        /// <returns>当前按钮文本</returns>
        public string GetClearButtonText()
        {
            if (clearButtonTextTMP != null)
            {
                return clearButtonTextTMP.text;
            }
            else if (clearButtonText != null)
            {
                return clearButtonText.text;
            }
            else
            {
                return "";
            }
        }
        
        /// <summary>
        /// 触发导出按钮点击（模拟用户点击）
        /// </summary>
        public void TriggerExportButton()
        {
            OnExportButtonClicked();
        }
        
        /// <summary>
        /// 直接导出数据（外部调用接口）
        /// </summary>
        /// <param name="fileName">自定义文件名（可选）</param>
        /// <returns>导出结果</returns>
        public ExportResult ExportDataDirect(string fileName = null)
        {
            try
            {
                // 获取BankingCtrl组件
                var bankingCtrl = GetComponent<BankingCtrl>();
                if (bankingCtrl == null)
                {
                    bankingCtrl = GetComponentInParent<BankingCtrl>();
                }
                
                if (bankingCtrl != null)
                {
                    // 获取银行数据
                    var bankingData = bankingCtrl.GetBankingData();
                    
                    if (bankingData != null)
                    {
                        // 执行导出（使用真正的Excel格式，同时复制到粘贴板）
                        return SimpleExcelExporter.ExportBankingDataToExcel(bankingData, fileName, true);
                    }
                    else
                    {
                        return new ExportResult(false, "银行数据为空，无法导出");
                    }
                }
                else
                {
                    return new ExportResult(false, "未找到BankingCtrl组件，无法导出数据");
                }
            }
            catch (System.Exception ex)
            {
                Debug.LogError($"[BankingView] 导出数据时发生错误: {ex.Message}\n{ex.StackTrace}");
                return new ExportResult(false, $"导出失败：{ex.Message}");
            }
        }
        
        /// <summary>
        /// 调试信息 - 检查所有组件状态
        /// </summary>
        public void DebugAllComponents()
        {
            Debug.Log($"=== BankingView 组件状态 ===");
            Debug.Log($"主面板: {(mainPanel != null ? mainPanel.name : "未找到")}");
            Debug.Log($"头部统计: {(headerStatistics != null ? "已找到" : "未找到")}");
            Debug.Log($"押注滚动列表: {(betScrollView != null ? "已找到" : "未找到")}");
            Debug.Log($"风险数据滚动列表: {(riskDataScrollView != null ? "已找到" : "未找到")}");
            Debug.Log($"关闭按钮: {(closeButton != null ? "已找到" : "未找到")}");
            Debug.Log($"清空按钮: {(clearButton != null ? "已找到" : "未找到")}");
            Debug.Log($"导出按钮: {(exportButton != null ? "已找到" : "未找到")}");
            Debug.Log($"清空按钮文本: {(clearButtonTextTMP != null ? $"已找到TextMeshPro - 当前文本: {clearButtonTextTMP.text}" : clearButtonText != null ? $"已找到传统Text - 当前文本: {clearButtonText.text}" : "未找到")}");
            Debug.Log($"清空按钮状态: {GetClearButtonState()}");
            
            // 调试押注滚动列表的详细状态
            if (betScrollView != null)
            {
                betScrollView.DebugComponentStatus();
            }
            
            // 调试风险数据滚动列表的详细状态
            if (riskDataScrollView != null)
            {
                riskDataScrollView.DebugComponentStatus();
            }
        }
        #endregion
        
        #region 生命周期
        /// <summary>
        /// 组件销毁时清理
        /// </summary>
        private void OnDestroy()
        {
            // 移除关闭按钮事件监听
            if (closeButton != null)
            {
                closeButton.onClick.RemoveListener(OnCloseButtonClicked);
            }
            
            // 移除清空按钮事件监听
            if (clearButton != null)
            {
                clearButton.onClick.RemoveListener(OnClearButtonClicked);
            }
            
            // 移除导出按钮事件监听
            if (exportButton != null)
            {
                exportButton.onClick.RemoveListener(OnExportButtonClicked);
            }
            
            Debug.Log("[BankingView] 组件已销毁，事件监听已清理");
        }
        #endregion
    }
} 